//class Solution {
//public:
//    int lengthOfLIS(vector<int>& nums) {
//        int n = nums.size();
//        if (n == 1)return 1;
//        vector<int> dp(n + 1, 1);
//        int ret = 1;
//        for (int i = 1; i <= n; i++)
//        {
//            for (int j = i - 1; j > 0; j--)
//            {
//                if (nums[i - 1] > nums[j - 1])
//                {
//                    dp[i] = max(dp[i], dp[j] + 1);
//                    ret = max(ret, dp[i]);
//                }
//            }
//        }
//        return ret;
//    }
//};
//
//
////#include<iostream>
////using namespace std;
////#include<vector>
////
////int main()
////{
////	vector<int> vt = { 1,2,3,4,5 };
////	for (auto it = vt.begin(); it != vt.end(); it++)
////	{
////		cout << *it;
////	}
////	return 0;
////}
//
//
//class Solution {
//public:
//    int wiggleMaxLength(vector<int>& nums) {
//        int n = nums.size();
//        vector<int> ss(n + 1, 1);
//        vector<int> xj(n + 1, 1);
//        int ret = 1;
//        for (int i = 1; i < n; i++)
//        {
//            for (int j = i - 1; j >= 0; j--)
//            {
//                if (nums[i] > nums[j])
//                {
//                    ss[i] = max(ss[i], xj[j] + 1);
//                    ret = max(ss[i], ret);
//                }
//                if (nums[i] < nums[j])
//                {
//                    xj[i] = max(xj[i], ss[j] + 1);
//                    ret = max(xj[i], ret);
//                }
//            }
//        }
//        return ret;
//    }
//};
//
//
//
//
//class Solution {
//public:
//    bool wordBreak(string s, vector<string>& wordDict) {
//        unordered_set<string> hash;
//        for (auto& e : wordDict)
//            hash.insert(e);
//
//        int n = s.size();
//
//        s = " " + s;
//        vector<bool> dp(n + 1, false);
//        dp[0] = true;
//        for (int i = 1; i <= n; i++)
//        {
//            for (int j = i; j > 0; j--)
//            {
//                if (hash.count(s.substr(j, i - j + 1)))
//                    dp[i] = dp[j - 1];
//                if (dp[i])
//                    break;
//
//            }
//        }
//        for (auto e : dp)
//            cout << e << " ";
//        return dp[n];
//    }
//};
//
//
//class Solution {
//public:
//    int findSubstringInWraproundString(string s) {
//        int n = s.size();
//        vector<int> dp(n, 1);
//        vector<int>hash(26);
//        int ret = 0;
//        for (int i = 1; i < n; i++)
//        {
//            if (s[i] == s[i - 1] + 1 || (s[i - 1] == 'z' && s[i] == 'a'))
//            {
//                dp[i] = dp[i - 1] + 1;
//            }
//        }
//        for (int i = 0; i < n; i++)
//        {
//            hash[s[i] - 'a'] = max(hash[s[i] - 'a'], dp[i]);
//        }
//        for (auto e : hash)
//            ret += e;
//        return ret;
//    }
//};
//
//class Solution {
//public:
//    int findNumberOfLIS(vector<int>& nums) {
//        int n = nums.size();
//        vector<int> len(n, 1);
//        vector<int> count(n, 1);
//        int _len = 1;
//        int _count = 1;
//        for (int i = 1; i < n; i++)
//        {
//            for (int j = 0; j < i; j++)
//            {
//                if (nums[j] < nums[i])
//                {
//                    if (len[j] + 1 > len[i])
//                    {
//                        count[i] = count[j];
//                        len[i] = len[j] + 1;
//                    }
//                    else if (len[j] + 1 == len[i])
//                    {
//                        count[i] += count[j];
//                    }
//                }
//
//            }
//            if (len[i] > _len)
//            {
//                _len = len[i];
//                _count = count[i];
//            }
//            else if (len[i] == _len)
//                _count += count[i];
//        }
//        return _count;
//    }
//};
//
//
//class Solution {
//public:
//
//    int findLongestChain(vector<vector<int>>& pairs) {
//        int n = pairs.size();
//
//        sort(pairs.begin(), pairs.end());
//        for (auto e : pairs)
//        {
//            cout << e[0] << "-" << e[1] << " ";
//        }
//        vector<int> dp(n, 1);
//        int ret = 1;
//        for (int i = 1; i < n; i++)
//        {
//            for (int j = i - 1; j >= 0; j--)
//            {
//                if (pairs[i][0] > pairs[j][1])
//                {
//                    dp[i] = max(dp[j] + 1, dp[i]);
//                    ret = max(ret, dp[i]);
//                }
//            }
//        }
//        return ret;
//    }
//};
//


#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;

struct Sort
{
	bool operator()(const int a, const int b)
	{
		return a < b;
	}
};
int main()
{
	vector<int> vt = { 1,4,9,7,5,7,1,10 };
	sort(vt.begin(), vt.end(), Sort());

	for (auto e : vt)
		cout << e << " ";
}